package cn.tedu.user.management.service.impl;

import cn.tedu.rtms.commons.ex.ServiceException;
import cn.tedu.rtms.commons.pojo.vo.PageData;
import cn.tedu.rtms.commons.web.ServiceCode;
import cn.tedu.user.management.dao.persist.repository.IJobRepository;
import cn.tedu.user.management.dao.persist.repository.ISectionJobRepository;
import cn.tedu.user.management.dao.persist.repository.IUserRepository;
import cn.tedu.user.management.pojo.entity.Job;
import cn.tedu.user.management.pojo.entity.SectionJob;
import cn.tedu.user.management.pojo.param.JobAddNewParam;
import cn.tedu.user.management.pojo.param.JobUpdateInfoParam;
import cn.tedu.user.management.pojo.vo.*;
import cn.tedu.user.management.service.IJobService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 处理职位数据的业务实现类
 *
 * @author java@tedu.cn
 * @version 0.0.1
 */
@Slf4j
@Service
public class JobServiceImpl implements IJobService {

    @Value("${csmall.crud.default-query-page-size}")
    private Integer defaultQueryPageSize;
    @Value("${csmall.jwt.secret-key}")
    private String secretKey;
    @Value("${csmall.jwt.duration-in-minute}")
    private Long durationInMinute;
    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private IJobRepository jobRepository;
    @Autowired
    private IUserRepository userRepository;
    @Autowired
    private ISectionJobRepository sectionJobRepository;
    /*@Autowired
    private IJobRoleRepository jobRoleRepository;*/
    /*@Autowired
    private IJobJwtRepository jobCacheRepository;*/
    @Autowired
    private AuthenticationManager authenticationManager;

    public JobServiceImpl() {
        log.debug("创建业务类对象：JobServiceImpl");
    }

    @Override
    public void addNew(JobAddNewParam jobAddNewParam) {
        log.debug("开始处理【添加职位】的业务，参数：{}", jobAddNewParam);

        // 从参数对象中获取职位的职位名
        String jobName = jobAddNewParam.getJobName();
        //从参数对象中获取部门id
        Long sectionId = jobAddNewParam.getSectionId();
        Long jobId = jobRepository.selectJobIdByJobName(jobName);

        // 调用Mapper对象的countBySectionIdAndJobId()执行统计
        int count = sectionJobRepository.countBySectionIdAndJobId(sectionId, jobId);
        // 判断统计结果是否大于0
        if (count > 0) {
            // 是：抛出异常
            String message = "添加职位失败，该部门此职位名已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 创建Job对象
        Job job = new Job();
        // 复制属性
        BeanUtils.copyProperties(jobAddNewParam, job);
        int rows1 = jobRepository.insert(job);

        // 创建SectionJob对象
        SectionJob sectionJob = new SectionJob();
        // 复制属性
        sectionJob.setSectionId(sectionId);
        sectionJob.setJobId(job.getId());
        int rows2 = sectionJobRepository.insert(sectionJob);


        if (rows1 != 1 || rows2 != 1) {
            String message = "添加职位失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_INSERT, message);
        }
    }

    @Override
    public void delete(Long id) {
        log.debug("开始处理【根据部门职位id删除职位】的业务，参数：{}", id);
        // 检查尝试删除的数据是否存在
        int count = sectionJobRepository.countById(id);
        if (count != 1) {
            String message = "删除职位失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        //查询此部门职位是否有人任职
        log.debug("开始处理【根据部门职位id查询任职人数】的业务，参数：{}", id);
        // 检查尝试删除的数据是否存在
        count = userRepository.countBySectionJobId(id);
        if (count > 0) {
            String message = "删除职位失败，当前职位尚且有人任职！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE, message);
        }

        //查询职位(部门不同)总数量
        log.debug("开始处理【查询职位(部门不同)总数量】的业务，部门职位关联表id：{}", id);
        count = jobRepository.countBySectionJobId(id);

        if(count > 1) {
            //同职位不同部门
            log.debug("同职位不同部门，参数：{}", id);
        } else if(count == 1){
            //独一无二的部门，需要删除
            log.debug("独一无二的部门，参数：{}", id);
            //count=1,因此返回结果只有一个
            Long jobId = sectionJobRepository.selectJobIdById(id);

            //执行删除，删除job表中数据
            int rows = jobRepository.deleteById(jobId);
            //rows = jobRepository.deleteById(id);
            if (rows != 1) {
                String message = "删除部门职位关联数据失败，服务器忙，请稍后再尝试！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_DELETE, message);
            }
        } else {
            String message = "删除职位数据失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE, message);
        }

        // 执行删除--部门职位关联表
        log.debug("即将执行删除部门职位数据，参数：{}", id);
        int rows = sectionJobRepository.deleteById(id);
        if (rows != 1) {
            String message = "删除部门职位关联数据失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_DELETE, message);
        }

    }

    @Override
    public PageData<JobListItemVO> list(Integer pageNum) {
        log.debug("开始处理【查询职位列表】的业务，页码：{}", pageNum);
        PageData<JobListItemVO> pageData = jobRepository.list(pageNum, defaultQueryPageSize);
        return pageData;
    }

    @Override
    public PageData<JobListItemVO> list(Integer pageNum, Integer pageSize) {
        log.debug("开始处理【查询职位列表】的业务，页码：{}，每页记录数：{}", pageNum, pageSize);
        PageData<JobListItemVO> pageData = jobRepository.list(pageNum, pageSize);
        return pageData;
    }

    @Override
    public void updateInfoById(Long id, JobUpdateInfoParam jobUpdateInfoParam) {
        log.debug("开始处理【修改职位信息】的业务，ID：{}，新数据：{}", id, jobUpdateInfoParam);
        // 调用Mapper对象的getStandardById()执行查询，此id为section_job表中的id;
        JobStandardVO queryResult = jobRepository.getStandardById(id);
        // 判断查询结果是否为null
        if (queryResult == null) {
            // 是：抛出异常
            String message = "修改职位信息失败，尝试修改的职位数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        //根据section_job表中的id查询sectionName和jobName等相关数据
        JobRawVO jobRaw = jobRepository.getInfoById(id);
        log.debug("根据【section_job】表中的id查询sectionName和jobName等相关数据,{}",jobRaw);
        String jobNameVO = jobRaw.getJobName();
        Long sectionIdVO = jobRaw.getSectionId();
        Long jobIdVO = jobRaw.getJobId();

        //获取jobName
        String jobName = jobUpdateInfoParam.getJobName();
        // 创建Job对象
        Job job = new Job();
        //更新数据
        job.setId(jobIdVO);
        job.setJobName(jobName);
        job.setDescription(jobUpdateInfoParam.getDescription());
        job.setSort(jobUpdateInfoParam.getSort());

        if(jobNameVO.equals(jobName)){
            // 执行修改
            updateJobById(job);
        } else {
            //查询jobName在job表中的数量
            int count = jobRepository.countByJobName(jobName);
            if(count > 0){
                String message = "修改职位信息失败，该职位已存在！";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
            }
            // 执行修改
            updateJobById(job);
        }
        //判断是否需要更换部门
        if(jobUpdateInfoParam.getSectionId()!=null){
            Long sectionId = jobUpdateInfoParam.getSectionId()[jobUpdateInfoParam.getSectionId().length-1];
            log.debug("开始处理【更新部门职位关联表】的业务，sectionId: {}", sectionId);
            //判断sectionId是否真的需要改变
            if(!sectionId.equals(sectionIdVO)) {
                //根据sectionId和jobId查看数量
                int count = sectionJobRepository.countBySectionIdAndJobId(sectionId, jobIdVO);
                if(count>0){
                    String message = "修改职位信息失败，该部门此职位已存在！";
                    log.warn(message);
                    throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
                } else {
                    //创建sectionJob对象
                    SectionJob sectionJob = new SectionJob();
                    sectionJob.setId(id);
                    sectionJob.setSectionId(sectionId);
                    int rows = sectionJobRepository.update(sectionJob);
                    if (rows != 1) {
                        String message = "修改职位信息失败，部门职位关联表修改失败!";
                        log.warn(message);
                        throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
                    }
                }
            }

        }

    }

    private void updateJobById(Job job){
        log.debug("开始处理【修改职位信息】的业务,job:{}", job);
        int rows = jobRepository.update(job);
        if (rows != 1) {
            String message = "修改职位信息失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
        }
    }

    @Override
    public JobStandardVO getStandardById(Long id) {
        log.debug("开始处理【根据ID查询职位信息】的业务，参数：{}", id);
        JobStandardVO queryResult = jobRepository.getStandardById(id);
        if (queryResult == null) {
            // 是：抛出异常
            String message = "查询职位信息失败，职位数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        return queryResult;
    }

    @Override
    public void setEnable(Long id) {
        updateEnableById(id, 1);
    }

    @Override
    public void setDisable(Long id) {
        updateEnableById(id, 0);
    }

    @Override
    public List<JobEnableListItemVO> enableList(Long sectionId) {
        log.debug("开始处理【查询招聘职位】的业务，查询招聘职位：部门id:{}", sectionId);
        //0为前端默认值，若为选择部门，则传递的参数就是0
        if (sectionId == 0) {
            String message = "查询职位失败，请先选择部门！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }
        List<JobEnableListItemVO> enableList = sectionJobRepository.enableList(sectionId);
        //因为职位中可以选择父级部门，而父级部门可能是没有招聘的，需要换个部门
        if (enableList == null) {
            String message = "查询职位失败，该部门暂无招聘需求！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        return enableList;
    }

    private void updateEnableById(Long id, Integer enable) {
        log.debug("开始处理【{}职位】的业务，ID：{}，目标状态：{}", ENABLE_TEXT[enable], id, enable);
        // 检查数据是否存在
        JobStandardVO queryResult = jobRepository.getStandardById(id);
        if (queryResult == null) {
            String message = ENABLE_TEXT[enable] + "职位失败，尝试访问的数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_NOT_FOUND, message);
        }

        // 检查当前状态是否与参数表示的状态相同
        if (queryResult.getEnable().equals(enable)) {
            String message = ENABLE_TEXT[enable] + "职位失败，当前职位已经处于"
                    + ENABLE_TEXT[enable] + "状态！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_CONFLICT, message);
        }

        // 准备执行更新
        SectionJob sectionJobJob = new SectionJob();
        sectionJobJob.setId(id);
        sectionJobJob.setEnable(enable);
        log.debug("即将修改数据，参数：{}", sectionJobJob);
        int rows = sectionJobRepository.updateById(sectionJobJob);
        if (rows != 1) {
            String message = ENABLE_TEXT[enable] + "职位失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERROR_UPDATE, message);
        }
    }

    @Override
    public List<JobListItemVO> selectByKeywords(String Keywords) {
        log.debug("开始处理【根据关键字查询职位】的业务，关键字：{}", Keywords);
        List<JobListItemVO> list = jobRepository.selectByKeywords(Keywords);
        return list;
    }
}
